// src/main/main.js
const { app, BrowserWindow, dialog, ipcMain } = require('electron');
const MemoryAuthManager = require('./auth');
const DatabaseManager = require('./database');
const path = require('path');
const AdmZip = require('adm-zip');


let mainWindow;
let authManager;
let dbManager = null;
let ipcHandlersRegistered = false;

// 获取数据目录的辅助函数
function getDataPath(filename = '') {
  let dataDir;
  if (process.env.NODE_ENV === 'development') {
    dataDir = path.join(__dirname, '../data');
  } else {
    dataDir = path.join(app.getPath('userData'), 'data');
  }
  
  if (filename) {
    return path.join(dataDir, filename);
  }
  return dataDir;
}

// 注册 IPC 处理器
function registerIpcHandlers() {
  if (ipcHandlersRegistered) {
    console.log('IPC 处理器已注册，跳过重复注册');
    return;
  }

  console.log('注册 IPC 处理器...');

  // 认证相关 IPC
  ipcMain.handle('auth-initialize', async () => {
    try {
      console.log('处理 auth-initialize 请求');
      
      if (!authManager) {
        authManager = new MemoryAuthManager();
      }
      
      const isFirstRun = await authManager.isFirstRun();
      console.log('是否是第一次运行:', isFirstRun);
      
      return { 
        isFirstRun,
        success: true 
      };
    } catch (error) {
      console.error('初始化检查失败:', error);
      return { 
        isFirstRun: true, 
        success: false, 
        error: error.message 
      };
    }
  });

  ipcMain.handle('auth-first-time-setup', async (event, { username, password }) => {
    try {
      console.log('处理首次设置请求:', { username });
      
      if (!authManager) {
        authManager = new MemoryAuthManager();
      }
      
      const result = await authManager.firstTimeSetup(username, password);
      console.log('首次设置结果:', result);
      
      if (result.success) {
        // 初始化数据库管理器
        const dbPath = getDataPath('system.db');
        dbManager = new DatabaseManager(dbPath, authManager);
        console.log('数据库管理器初始化完成');
      }
      
      return result;
    } catch (error) {
      console.error('首次设置失败:', error);
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('auth-login', async (event, { username, password }) => {
    try {
      console.log('处理登录请求:', { username });
      
      if (!authManager) {
        authManager = new MemoryAuthManager();
      }
      
      const result = await authManager.login(username, password);
      console.log('登录结果:', result);
      
      if (result.success) {
        // 初始化数据库管理器
        const dbPath = getDataPath('system.db');
        dbManager = new DatabaseManager(dbPath, authManager);
        console.log('数据库管理器初始化完成');
      }
      
      return result;
    } catch (error) {
      console.error('登录失败:', error);
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('auth-verify-session', async (event, { sessionId }) => {
    try {
      console.log('验证会话:', sessionId?.substring(0, 8) + '...');
      
      if (!authManager) {
        throw new Error('认证管理器未初始化');
      }
      
      const result = await authManager.verifySession(sessionId);
      return { success: true, ...result };
    } catch (error) {
      console.error('会话验证失败:', error);
      return { success: false, error: error.message };
    }
  });


  // 数据库操作 IPC
  ipcMain.handle('db-query', async (event, { sessionId, sql, params }) => {
    try {
      if (!dbManager) {
        throw new Error('数据库管理器未初始化');
      }
      
      const data = await dbManager.query(sessionId, sql, params);
      return { success: true, data };
    } catch (error) {
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('db-insert', async (event, { sessionId, sql, params }) => {
    try {
      if (!dbManager) {
        throw new Error('数据库管理器未初始化');
      }
      
      const id = await dbManager.insert(sessionId, sql, params);
      return { success: true, id };
    } catch (error) {
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('db-update', async (event, { sessionId, sql, params }) => {
    try {
      if (!dbManager) {
        throw new Error('数据库管理器未初始化');
      }
      
      const changes = await dbManager.update(sessionId, sql, params);
      return { success: true, changes };
    } catch (error) {
      return { success: false, error: error.message };
    }
  });

  // 新增批量插入处理
ipcMain.handle('db-batch-insert', async (event, { sessionId, sql, values }) => {
  try {
    if (!dbManager) {
      throw new Error('数据库管理器未初始化');
    }

    // ========== 关键：参数校验，确保 values 是数组 ==========
    if (!Array.isArray(values)) {
      throw new Error(`批量插入参数错误：values 必须是数组，当前类型为 ${typeof values}`);
    }
    if (values.length === 0) {
      throw new Error('批量插入参数错误：values 数组不能为空');
    }

    // 确保数据库连接
    await dbManager.connectWithSession(sessionId);
    
    // 使用事务执行批量插入
    const result = dbManager.db.transaction((sql, values) => {
      const stmt = dbManager.db.prepare(sql);
      let count = 0;
      // 遍历 values（此时已确保是数组）
      for (const params of values) {
        // 额外校验：每个 params 也需是数组（匹配 SQL 占位符的参数列表）
        if (!Array.isArray(params)) {
          throw new Error(`批量插入子项错误：params 必须是数组，当前项为 ${typeof params}`);
        }
        stmt.run(...params);
        count++;
      }
      return count;
    })(sql, values);

    return { success: true, count: result };
  } catch (error) {
    console.error('批量插入失败:', error);
    return { success: false, error: error.message }; // 返回明确的错误信息
  }
});

  // 文件操作 IPC
  ipcMain.handle('get-project-path', async () => {
    try {
      if (!mainWindow) {
        throw new Error('主窗口未初始化');
      }
      
      // 返回项目根目录作为默认路径
      const projectPath = path.join(__dirname, '../..');
      return { success: true, path: projectPath };
    } catch (error) {
      console.error('获取项目路径失败:', error);
      return { success: false, error: error.message };
    }
  });

  ipcMain.handle('show-open-dialog', async (event, options) => {
    try {
      if (!mainWindow) {
        throw new Error('主窗口未初始化');
      }
      
      const result = await dialog.showOpenDialog(mainWindow, {
        properties: options.properties || [],
        defaultPath: options.defaultPath || '',
        title: options.title || '选择文件或目录'
      });
      
      return {
        success: true,
        canceled: result.canceled,
        filePaths: result.filePaths || []
      };
    } catch (error) {
      console.error('显示打开对话框失败:', error);
      return { success: false, error: error.message };
    }
  });

  // 打开目录功能
  ipcMain.handle('open-directory', async (event, path) => {
    try {
      if (!mainWindow) {
        throw new Error('主窗口未初始化');
      }
      
      if (!path) {
        throw new Error('路径不能为空');
      }
      
      // 使用Electron的shell模块打开文件资源管理器
      const { shell } = require('electron');
      const fs = require('fs');
      const pathModule = require('path');

      // 确保路径是有效的字符串
      const normalizedPath = String(path).trim();
      
      // 使用path模块规范化路径
      const fullPath = pathModule.normalize(normalizedPath);
      
      console.log('打开目录 - 原始路径:', path);
      console.log('打开目录 - 规范化路径:', fullPath);
      
      // 检查路径是否存在
      if (!fs.existsSync(fullPath)) {
        throw new Error(`路径不存在: ${fullPath}`);
      }
      
      // 检查是否是目录
      const stats = fs.statSync(fullPath);
      if (!stats.isDirectory()) {
        throw new Error(`路径不是目录: ${fullPath}`);
      }
      
      // 使用 openPath 直接打开目录（而不是 showItemInFolder）
      // openPath 会直接打开目录，而 showItemInFolder 会打开父目录并选中该项
      const error = await shell.openPath(fullPath);
      if (error) {
        throw new Error(`打开目录失败: ${error}`);
      }
      
      console.log('目录已打开:', fullPath);
      return { success: true, path: fullPath };
    } catch (error) {
      console.error('打开目录失败:', error);
      return { 
        success: false, 
        error: error.message
      };
    }
  });

  // 读取文件功能
  ipcMain.handle('read-file', async (event, { filePath }) => {
    try {
      if (!filePath) {
        throw new Error('文件路径不能为空');
      }

      // 检查文件是否存在
      if (!fs.existsSync(filePath)) {
        throw new Error(`文件不存在: ${filePath}`);
      }

      // 读取文件内容
      const content = fs.readFileSync(filePath, 'utf8');
      
      return { 
        success: true, 
        content,
        size: fs.statSync(filePath).size
      };
    } catch (error) {
      console.error('读取文件失败:', error);
      return { 
        success: false, 
        error: error.message 
      };
    }
  });

  // 解密文件功能 - 使用与加密函数相同的AES算法
  ipcMain.handle('decrypt-file', async (event, { filePath, password }) => {
    try {
      if (!filePath) {
        throw new Error('文件路径不能为空');
      }
      if (!password) {
        throw new Error('密码不能为空');
      }

      // 检查文件是否存在
      if (!fs.existsSync(filePath)) {
        throw new Error(`文件不存在: ${filePath}`);
      }

      // 读取加密文件内容
      const encryptedContent = fs.readFileSync(filePath, 'utf8');
      
      // 使用与加密函数相同的AES算法解密
      const CryptoJS = require('crypto-js');
      const bytes = CryptoJS.AES.decrypt(encryptedContent, password);
      const decryptedContent = bytes.toString(CryptoJS.enc.Utf8);
      
      return { 
        success: true, 
        content: decryptedContent
      };
    } catch (error) {
      console.error('解密文件失败:', error);
      return { 
        success: false, 
        error: error.message 
      };
    }
  });

  // 数据库操作 IPC
  ipcMain.handle('db-delete', async (event, { sessionId, sql, params }) => {
    try {
      if (!dbManager) {
        throw new Error('数据库管理器未初始化');
      }
      
      const changes = await dbManager.delete(sessionId, sql, params);
      return { success: true, changes };
    } catch (error) {
      return { success: false, error: error.message };
    }
  });

// 应用退出
  ipcMain.handle('app-quit', async () => {
    try {
      console.log('收到退出应用请求');
      
      // 清理资源
      if (dbManager) {
        dbManager.disconnect();
        dbManager = null;
      }
      
      // 延迟退出，确保清理完成
      setTimeout(() => {
        app.quit();
      }, 100);
      
      return { success: true, message: '应用即将退出' };
    } catch (error) {
      return { success: false, error: error.message };
    }
  });

  // 文件写入处理函数
  ipcMain.handle('write-encrypted-file', async (event, { filePath, content }) => {
    try {
      const fs = require('fs');
      const path = require('path');
      
      // 确保目录存在
      const dir = path.dirname(filePath);
      if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir, { recursive: true });
      }
      
      // 写入文件
      fs.writeFileSync(filePath, content);
      return { success: true };
    } catch (error) {
      console.error('写入文件失败:', error);
      return { success: false, error: error.message };
    }
  });

  // 加密并写入文件处理函数
  ipcMain.handle('encrypt-and-write-file', async (event, { filePath, content, password }) => {
    try {
      const fs = require('fs');
      const path = require('path');
      const CryptoJS = require('crypto-js');
      
      // 确保目录存在
      const dir = path.dirname(filePath);
      if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir, { recursive: true });
      }
      
      // 使用CryptoJS进行AES加密
      const encrypted = CryptoJS.AES.encrypt(content, password).toString();
      
      // 写入加密后的文件
      fs.writeFileSync(filePath, encrypted);
      return { success: true };
    } catch (error) {
      console.error('加密并写入文件失败:', error);
      return { success: false, error: error.message };
    }
  });

  ipcHandlersRegistered = true;
  console.log('IPC 处理器注册完成');
}

// 创建窗口
async function createWindow() {
  try {
    // 获取应用程序路径，确保图标路径正确
    const fs = require('fs');
    let iconPath;
    
    if (process.env.NODE_ENV === 'development') {
      // 开发环境：使用 PNG 格式（icon.ico 实际上是 PNG）
      iconPath = path.resolve(__dirname, '../assets/images/icon.ico');
    } else {
      // 生产环境：从资源目录
      iconPath = path.join(process.resourcesPath, '/assets/images/icon.ico');
    }
    
    console.log('图标路径:', iconPath);
    console.log('图标文件是否存在:', fs.existsSync(iconPath));
    
    // 配置选项对象
    const windowConfig = {
      width: 1200,
      height: 800,
      webPreferences: {
        nodeIntegration: false,
        contextIsolation: true,
        preload: path.join(__dirname, 'preload.js')
      },
      show: false
    };
    
    // 只在文件存在时添加 icon 选项
    if (fs.existsSync(iconPath)) {
      windowConfig.icon = iconPath;
      console.log('图标已设置（PNG格式）');
    } else {
      console.log('图标文件不存在，使用默认图标');
    }
    
    mainWindow = new BrowserWindow(windowConfig);

    // 注册 IPC 处理器
    registerIpcHandlers();

    if (process.env.NODE_ENV === 'development') {
      await mainWindow.loadURL('http://localhost:5173');
      mainWindow.webContents.openDevTools();
    } else {
      // 修复：正确处理构建后的文件路径
      const distPath = path.join(__dirname, '../../dist');
      
      // 检查构建输出目录是否存在
      if (!fs.existsSync(distPath)) {
        console.error('构建输出目录不存在:', distPath);
        throw new Error('构建输出目录不存在，请先运行构建命令');
      }
      
      // 查找index.html文件
      const indexPath = path.join(distPath, 'index.html');
      if (!fs.existsSync(indexPath)) {
        console.error('index.html 文件不存在:', indexPath);
        throw new Error('找不到index.html文件，请检查构建过程');
      }
      
      console.log('加载文件:', indexPath);
      await mainWindow.loadFile(indexPath);
    }

    // 初始化认证管理器
    authManager = new MemoryAuthManager();
    
    // 检查认证状态
    await checkAuthentication();
    
  } catch (error) {
    console.error('创建窗口失败:', error);
  }
}

// 检查认证状态
async function checkAuthentication() {
  try {
    const isFirstRun = await authManager.isFirstRun();
    console.log('应用启动 - 是否是第一次运行:', isFirstRun);
    
    if (isFirstRun) {
      console.log('首次运行，显示登录页进行初始化');
      mainWindow.show();
      // 通知渲染进程需要初始化
      mainWindow.webContents.send('authentication-status', {
        status: 'first-run',
        requiresSetup: true
      });
      return;
    }
    
    // 检查是否有有效的会话
    const username = authManager.getUsernameFromConfig();
    console.log('配置中的用户名:', username);
    
    if (!username) {
      console.log('未找到用户配置，需要重新登录');
      mainWindow.show();
      mainWindow.webContents.send('authentication-status', {
        status: 'requires-login',
        reason: '用户配置不存在'
      });
      return;
    }
    
    // 由于是内存存储，重启后会话丢失，需要重新登录
    console.log('应用已重启，会话丢失，需要重新登录');
    mainWindow.show();
    mainWindow.webContents.send('authentication-status', {
      status: 'requires-login',
      reason: '会话已过期，请重新登录',
      username: username
    });
    
  } catch (error) {
    console.error('认证检查失败:', error);
    mainWindow.show();
    mainWindow.webContents.send('authentication-status', {
      status: 'error',
      reason: error.message
    });
  }
}

// 应用事件
app.whenReady().then(() => {
  console.log('应用准备就绪，创建窗口...');
  createWindow();
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

app.on('before-quit', () => {
  console.log('应用即将退出，清理资源...');
  if (dbManager) {
    dbManager.disconnect();
  }
});

app.on('activate', () => {
  if (BrowserWindow.getAllWindows().length === 0) {
    createWindow();
  }
});

// 获取用户信息
ipcMain.handle('get-user-info', async (event, { sessionId }) => {
  try {
    console.log('获取用户信息，会话ID:', sessionId?.substring(0, 8) + '...');
    
    if (!authManager) {
      throw new Error('认证管理器未初始化');
    }
    
    if (!sessionId) {
      throw new Error('会话ID不能为空');
    }
    
    // 验证会话并获取用户信息
    const session = await authManager.verifySession(sessionId);
    if (!session.isAuthenticated) {
      throw new Error('会话无效');
    }
    
    return {
      success: true,
      username: session.username,
      loginTime: session.loginTime,
      expiresAt: session.expiresAt
    };
  } catch (error) {
    console.error('获取用户信息失败:', error);
    return {
      success: false,
      error: error.message
    };
  }
});

// 修复退出登录处理器
ipcMain.handle('auth-logout', async (event, { sessionId }) => {
  try {
    console.log('处理退出登录请求，会话ID:', sessionId?.substring(0, 8) + '...');
    
    if (!authManager) {
      return { success: true, message: '已安全退出' };
    }
    
    const result = await authManager.logout(sessionId);
    
    // 断开数据库连接
    if (dbManager) {
      dbManager.disconnect();
      dbManager = null;
    }
    
    console.log('退出登录成功');
    return result;
  } catch (error) {
    console.error('退出登录失败:', error);
    return { success: false, error: error.message };
  }
});
// 备份和还原相关IPC
const fs = require('fs');
const JSZip = require('jszip');

ipcMain.handle('perform-backup', async (event, { backupPath, password }) => {
  try {
    // 确保备份路径存在
    if (!fs.existsSync(backupPath)) {
      fs.mkdirSync(backupPath, { recursive: true });
    }

    // 生成备份文件名
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const backupFileName = `data_backup_${timestamp}.zip`;
    const backupFilePath = path.join(backupPath, backupFileName);

    // 创建JSZip实例
    const zip = new JSZip();

    // 获取数据库路径
    const dbPath = getDataPath('system.db');
    
    // 检查数据库文件是否存在
    if (!fs.existsSync(dbPath)) {
      throw new Error('数据库文件不存在');
    }

    // 确保 dbManager 已连接，需要获取 sessionId 来连接
    if (!dbManager) {
      throw new Error('数据库管理器未初始化');
    }

    // 如果 dbManager 还没有连接，尝试获取一个活跃会话来连接
    if (!dbManager.db) {
      // 获取任意活跃的会话 ID 来初始化数据库连接
      const sessions = authManager.sessions;
      let sessionId = null;
      
      if (sessions && sessions.size > 0) {
        sessionId = Array.from(sessions.keys())[0];
        console.log('使用会话 ID 连接数据库:', sessionId?.substring(0, 8) + '...');
        await dbManager.connectWithSession(sessionId);
      }
      
      if (!dbManager.db) {
        throw new Error('无法初始化数据库连接，请确保已登录');
      }
    }

    // 关键：执行 WAL checkpoint，确保 WAL 文件中的数据写回主数据库
    // 这会将 WAL 日志中的所有数据写回主数据库文件
    try {
      const checkpointResult = dbManager.db.pragma('wal_checkpoint(RESTART)');
      console.log('WAL checkpoint 执行结果:', checkpointResult);
    } catch (checkpointError) {
      console.warn('WAL checkpoint 执行出警告:', checkpointError.message);
    }
    
    // 再执行一次 TRUNCATE 以清理 WAL 文件
    try {
      dbManager.db.pragma('wal_checkpoint(TRUNCATE)');
      console.log('WAL checkpoint TRUNCATE 执行成功');
    } catch (truncateError) {
      console.warn('WAL checkpoint TRUNCATE 执行出警告:', truncateError.message);
    }
    
    // 等待一下，确保所有操作完成
    await new Promise(resolve => setTimeout(resolve, 200));
    
    // 直接读取数据库文件内容（此时所有数据都已在主文件中）
    const dbContent = fs.readFileSync(dbPath);
    
    // 添加数据库文件到压缩包
    if (password) {
      const CryptoJS = require('crypto-js');
      const encrypted = CryptoJS.AES.encrypt(dbContent.toString('base64'), password).toString();
      zip.file('system.db', encrypted);
      zip.file('system.db.encrypted', 'true'); // 添加标记文件表明这是加密的
    } else {
      zip.file('system.db', dbContent);
    }

    // 添加配置文件（如果存在）
    const configPath = getDataPath('config.json');
    if (fs.existsSync(configPath)) {
      const configContent = fs.readFileSync(configPath);
      zip.file('config.json', configContent);
    }

    // 生成ZIP文件
    const zipContent = await zip.generateAsync({ 
      type: 'nodebuffer',
      compression: 'DEFLATE',
      compressionOptions: {
        level: 9
      }
    });

    // 写入文件
    fs.writeFileSync(backupFilePath, zipContent);

    console.log(`备份文件已创建: ${backupFilePath}`);
    return { 
      success: true, 
      filePath: backupFilePath,
      encrypted: !!password
    };
  } catch (error) {
    console.error('备份失败:', error);
    return { success: false, error: error.message };
  }
});

ipcMain.handle('perform-preRestoreBackUp', async (event, { backupPath, password }) => {
  try {
    // 确保备份路径存在
    if (!fs.existsSync(backupPath)) {
      fs.mkdirSync(backupPath, { recursive: true });
    }

    // 生成备份文件名
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const backupFileName = `preRestoreBackUp_${timestamp}.zip`;
    const backupFilePath = path.join(backupPath, backupFileName);

    // 创建JSZip实例
    const zip = new JSZip();

    // 获取数据库路径
    const dbPath = getDataPath('system.db');
    
    // 检查数据库文件是否存在
    if (!fs.existsSync(dbPath)) {
      throw new Error('数据库文件不存在');
    }

    // 确保 dbManager 已连接，需要获取 sessionId 来连接
    if (!dbManager) {
      throw new Error('数据库管理器未初始化');
    }

    // 如果 dbManager 还没有连接，尝试获取一个活跃会话来连接
    if (!dbManager.db) {
      // 获取任意活跃的会话 ID 来初始化数据库连接
      const sessions = authManager.sessions;
      let sessionId = null;
      
      if (sessions && sessions.size > 0) {
        sessionId = Array.from(sessions.keys())[0];
        console.log('使用会话 ID 连接数据库:', sessionId?.substring(0, 8) + '...');
        await dbManager.connectWithSession(sessionId);
      }
      
      if (!dbManager.db) {
        throw new Error('无法初始化数据库连接，请确保已登录');
      }
    }

    // 关键：执行 WAL checkpoint，确保 WAL 文件中的数据写回主数据库
    // 这会将 WAL 日志中的所有数据写回主数据库文件
    try {
      const checkpointResult = dbManager.db.pragma('wal_checkpoint(RESTART)');
      console.log('WAL checkpoint 执行结果:', checkpointResult);
    } catch (checkpointError) {
      console.warn('WAL checkpoint 执行出警告:', checkpointError.message);
    }
    
    // 再执行一次 TRUNCATE 以清理 WAL 文件
    try {
      dbManager.db.pragma('wal_checkpoint(TRUNCATE)');
      console.log('WAL checkpoint TRUNCATE 执行成功');
    } catch (truncateError) {
      console.warn('WAL checkpoint TRUNCATE 执行出警告:', truncateError.message);
    }
    
    // 等待一下，确保所有操作完成
    await new Promise(resolve => setTimeout(resolve, 200));
    
    // 直接读取数据库文件内容（此时所有数据都已在主文件中）
    const dbContent = fs.readFileSync(dbPath);
    
    // 添加数据库文件到压缩包
    if (password) {
      const CryptoJS = require('crypto-js');
      const encrypted = CryptoJS.AES.encrypt(dbContent.toString('base64'), password).toString();
      zip.file('system.db', encrypted);
      zip.file('system.db.encrypted', 'true'); // 添加标记文件表明这是加密的
    } else {
      zip.file('system.db', dbContent);
    }

    // 添加配置文件（如果存在）
    const configPath = getDataPath('config.json');
    if (fs.existsSync(configPath)) {
      const configContent = fs.readFileSync(configPath);
      zip.file('config.json', configContent);
    }

    // 生成ZIP文件
    const zipContent = await zip.generateAsync({ 
      type: 'nodebuffer',
      compression: 'DEFLATE',
      compressionOptions: {
        level: 9
      }
    });

    // 写入文件
    fs.writeFileSync(backupFilePath, zipContent);

    console.log(`备份文件已创建: ${backupFilePath}`);
    return { 
      success: true, 
      filePath: backupFilePath,
      encrypted: !!password
    };
  } catch (error) {
    console.error('备份失败:', error);
    return { success: false, error: error.message };
  }
});

ipcMain.handle('perform-restore', async (event, { backupPath, password }) => {
  try {
    // 获取备份文件列表
    const files = fs.readdirSync(backupPath);
    const zipFiles = files.filter(file => file.endsWith('.zip') && file.startsWith('data_backup_'));

    if (zipFiles.length === 0) {
      throw new Error('未找到备份文件');
    }

    // 选择最新的备份文件
    const latestBackup = zipFiles.sort().pop();
    const backupFilePath = path.join(backupPath, latestBackup);

    console.log('开始还原备份文件:', backupFilePath);

    // 获取数据库路径
    const dbPath = getDataPath('system.db');
    const tempDbPath = getDataPath('system.db.temp');

    // 关键：先断开数据库连接，才能删除 WAL 文件
    console.log('断开数据库连接...');
    if (dbManager && dbManager.db) {
      dbManager.disconnect();
      dbManager = null;
    }

    // 等待一下，确保数据库连接完全释放
    await new Promise(resolve => setTimeout(resolve, 300));

    // 创建临时数据库文件备份
    if (fs.existsSync(dbPath)) {
      fs.copyFileSync(dbPath, tempDbPath);
    }

    // 读取ZIP文件内容
    const zipContent = fs.readFileSync(backupFilePath);
    const zip = new JSZip();
    await zip.loadAsync(zipContent);

    console.log('ZIP 文件内容:', Object.keys(zip.files));

    // 查找 system.db 文件（可能有目录前缀）
    let dbFileEntry = null;
    let dbFileName = null;
    for (const [fileName, entry] of Object.entries(zip.files)) {
      if (fileName.endsWith('system.db') && !entry.dir) {
        dbFileEntry = entry;
        dbFileName = fileName;
        break;
      }
    }

    if (!dbFileEntry) {
      throw new Error('备份文件中找不到 system.db 文件，ZIP 中的文件有: ' + Object.keys(zip.files).join(', '));
    }

    console.log('找到数据库文件:', dbFileName);

    // 检查是否是加密的备份
    let isEncrypted = false;
    for (const fileName of Object.keys(zip.files)) {
      if (fileName.endsWith('system.db.encrypted')) {
        const encryptedFlag = await zip.files[fileName].async('string');
        isEncrypted = encryptedFlag === 'true';
        break;
      }
    }
    
    console.log('备份文件加密状态:', isEncrypted);

    // 解压文件
    let dbContent;
    if (isEncrypted) {
      if (!password) {
        throw new Error('备份文件已加密，需要提供密码');
      }
      
      // 解密文件
      const CryptoJS = require('crypto-js');
      const encryptedContent = await dbFileEntry.async('string');
      try {
        const bytes = CryptoJS.AES.decrypt(encryptedContent, password);
        const decrypted = bytes.toString(CryptoJS.enc.Utf8);
        dbContent = Buffer.from(decrypted, 'base64');
      } catch (decryptError) {
        throw new Error('解密失败：密码不正确或文件已损坏');
      }
    } else {
      // 直接获取文件内容
      dbContent = await dbFileEntry.async('nodebuffer');
    }

    // 确保目录存在
    const dataDir = getDataPath();
    if (!fs.existsSync(dataDir)) {
      fs.mkdirSync(dataDir, { recursive: true });
    }

    // 关键：删除 WAL 相关文件（必须在断开连接后）
    // 这很重要，因为 SQLite 会优先使用 WAL 文件中的数据
    console.log('清理 WAL 相关文件...');
    
    // 删除 WAL 文件
    const walPath = dbPath + '-wal';
    if (fs.existsSync(walPath)) {
      try {
        fs.unlinkSync(walPath);
        console.log('已删除 WAL 文件:', walPath);
      } catch (walError) {
        console.warn('删除 WAL 文件失败:', walError.message);
        // 继续尝试删除其他文件
      }
    }
    
    // 删除 SHM 文件（共享内存文件）
    const shmPath = dbPath + '-shm';
    if (fs.existsSync(shmPath)) {
      try {
        fs.unlinkSync(shmPath);
        console.log('已删除 SHM 文件:', shmPath);
      } catch (shmError) {
        console.warn('删除 SHM 文件失败:', shmError.message);
        // 继续尝试写入新的 db 文件
      }
    }

    // 写入数据库文件
    fs.writeFileSync(dbPath, dbContent);
    console.log('数据库文件已还原:', dbPath);

    // 处理配置文件
    for (const [fileName, entry] of Object.entries(zip.files)) {
      if (fileName.endsWith('config.json') && !entry.dir) {
        const configContent = await entry.async('nodebuffer');
        const destConfigPath = getDataPath('config.json');
        fs.writeFileSync(destConfigPath, configContent);
        console.log('配置文件已还原:', destConfigPath);
        break;
      }
    }

    // 还原成功后，断开当前数据库连接并重新初始化
    if (dbManager && dbManager.db) {
      dbManager.disconnect();
      dbManager = null;
    }

    // 重新初始化数据库管理器，确保新的数据库文件可用
    const dbPath2 = getDataPath('system.db');
    dbManager = new DatabaseManager(dbPath2, authManager);
    console.log('数据库管理器已重新初始化');

    return { success: true, message: '数据还原成功' };
  } catch (error) {
    console.error('还原失败:', error);
    return { success: false, error: error.message };
  }
});

// 添加获取会话统计信息（调试用）
ipcMain.handle('get-session-stats', async () => {
  try {
    if (!authManager) {
      return { success: false, error: '认证管理器未初始化' };
    }
    
    const stats = authManager.getSessionStats();
    return { success: true, stats };
  } catch (error) {
    return { success: false, error: error.message };
  }
});